Sky at Night 2007 June/SAN CD 6-2007 CD-ROM 25.iso/pc/Software/AstroGrav_Win/Java/jre1.6.0/lib/rt.jar/java/io/PipedReader.class

Java Class File | 2006-11-29 | 2.5 KB | 219 lines

package java.io;

public class PipedReader extends Reader {
   boolean closedByWriter;
   boolean closedByReader;
   boolean connected;
   Thread readSide;
   Thread writeSide;
   private static final int DEFAULT_PIPE_SIZE = 1024;
   char[] buffer;
   // $FF: renamed from: in int
   int field_0;
   int out;

   public PipedReader(PipedWriter var1) throws IOException {
      this(var1, 1024);
   }

   public PipedReader(PipedWriter var1, int var2) throws IOException {
      this.closedByWriter = false;
      this.closedByReader = false;
      this.connected = false;
      this.field_0 = -1;
      this.out = 0;
      this.initPipe(var2);
      this.connect(var1);
   }

   public PipedReader() {
      this.closedByWriter = false;
      this.closedByReader = false;
      this.connected = false;
      this.field_0 = -1;
      this.out = 0;
      this.initPipe(1024);
   }

   public PipedReader(int var1) {
      this.closedByWriter = false;
      this.closedByReader = false;
      this.connected = false;
      this.field_0 = -1;
      this.out = 0;
      this.initPipe(var1);
   }

   private void initPipe(int var1) {
      if (var1 <= 0) {
         throw new IllegalArgumentException("Pipe size <= 0");
      } else {
         this.buffer = new char[var1];
      }
   }

   public void connect(PipedWriter var1) throws IOException {
      var1.connect(this);
   }

   synchronized void receive(int var1) throws IOException {
      if (!this.connected) {
         throw new IOException("Pipe not connected");
      } else if (!this.closedByWriter && !this.closedByReader) {
         if (this.readSide != null && !this.readSide.isAlive()) {
            throw new IOException("Read end dead");
         } else {
            this.writeSide = Thread.currentThread();

            while(this.field_0 == this.out) {
               if (this.readSide != null && !this.readSide.isAlive()) {
                  throw new IOException("Pipe broken");
               }

               this.notifyAll();

               try {
                  this.wait(1000L);
               } catch (InterruptedException var3) {
                  throw new InterruptedIOException();
               }
            }

            if (this.field_0 < 0) {
               this.field_0 = 0;
               this.out = 0;
            }

            this.buffer[this.field_0++] = (char)var1;
            if (this.field_0 >= this.buffer.length) {
               this.field_0 = 0;
            }

         }
      } else {
         throw new IOException("Pipe closed");
      }
   }

   synchronized void receive(char[] var1, int var2, int var3) throws IOException {
      while(true) {
         --var3;
         if (var3 < 0) {
            return;
         }

         this.receive(var1[var2++]);
      }
   }

   synchronized void receivedLast() {
      this.closedByWriter = true;
      this.notifyAll();
   }

   public synchronized int read() throws IOException {
      if (!this.connected) {
         throw new IOException("Pipe not connected");
      } else if (this.closedByReader) {
         throw new IOException("Pipe closed");
      } else if (this.writeSide != null && !this.writeSide.isAlive() && !this.closedByWriter && this.field_0 < 0) {
         throw new IOException("Write end dead");
      } else {
         this.readSide = Thread.currentThread();
         int var1 = 2;

         while(this.field_0 < 0) {
            if (this.closedByWriter) {
               return -1;
            }

            if (this.writeSide != null && !this.writeSide.isAlive()) {
               --var1;
               if (var1 < 0) {
                  throw new IOException("Pipe broken");
               }
            }

            this.notifyAll();

            try {
               this.wait(1000L);
            } catch (InterruptedException var3) {
               throw new InterruptedIOException();
            }
         }

         char var2 = this.buffer[this.out++];
         if (this.out >= this.buffer.length) {
            this.out = 0;
         }

         if (this.field_0 == this.out) {
            this.field_0 = -1;
         }

         return var2;
      }
   }

   public synchronized int read(char[] var1, int var2, int var3) throws IOException {
      if (!this.connected) {
         throw new IOException("Pipe not connected");
      } else if (this.closedByReader) {
         throw new IOException("Pipe closed");
      } else if (this.writeSide != null && !this.writeSide.isAlive() && !this.closedByWriter && this.field_0 < 0) {
         throw new IOException("Write end dead");
      } else if (var2 >= 0 && var2 <= var1.length && var3 >= 0 && var2 + var3 <= var1.length && var2 + var3 >= 0) {
         if (var3 == 0) {
            return 0;
         } else {
            int var4 = this.read();
            if (var4 < 0) {
               return -1;
            } else {
               var1[var2] = (char)var4;
               int var5 = 1;

               while(this.field_0 >= 0) {
                  --var3;
                  if (var3 <= 0) {
                     break;
                  }

                  var1[var2 + var5] = this.buffer[this.out++];
                  ++var5;
                  if (this.out >= this.buffer.length) {
                     this.out = 0;
                  }

                  if (this.field_0 == this.out) {
                     this.field_0 = -1;
                  }
               }

               return var5;
            }
         }
      } else {
         throw new IndexOutOfBoundsException();
      }
   }

   public synchronized boolean ready() throws IOException {
      if (!this.connected) {
         throw new IOException("Pipe not connected");
      } else if (this.closedByReader) {
         throw new IOException("Pipe closed");
      } else if (this.writeSide != null && !this.writeSide.isAlive() && !this.closedByWriter && this.field_0 < 0) {
         throw new IOException("Write end dead");
      } else {
         return this.field_0 >= 0;
      }
   }

   public void close() throws IOException {
      this.field_0 = -1;
      this.closedByReader = true;
   }
}